#include "IntercaladorMod.h"
#include "Indexador.h"

void engine_interIM(char*, char*, char*, char*);
void geraArquIM(char*, char*);
int pegaStringIM(char*, char*, FILE *, int*);
int trataFimArquiIM(int, int tag1, char* reg1, char* prr1, FILE* index1, FILE* indexF, char* reg2, int);

void filtre(char *paisP, char *nome2Arqu, char* nome3Arqu)
{
    char pais[100], nome2[100], exten[] = EXTENIDX;
    char nomeF[200], nome3[100];

    strcpy(pais, paisP);
    strcpy(nome2, nome2Arqu);
    strcpy(nome3, nome3Arqu);

    //gerando os index
    gera_index(pais);
    gera_index(nome2);
    gera_index(nome3);

    //gerando o nome do arqui final
    strcpy(nomeF, "3_");
    strcat(nomeF, pais);
    strcat(nomeF, ".aux");

    //gerando os nomes dos arquis
    colocaExten(pais, exten);
    colocaExten(nome2, exten);
    colocaExten(nome3, exten);

    engine_interIM(pais, nome2, nome3, nomeF);
    
    geraArquIM(nomeF, pais);
    //printf("porra");
}

void engine_interIM(char *nome1Arqu, char *nome2Arqu, char *nome3Arqu, char *nomeF)
{
    //variveis
    char reg[3][200], prr[3][20], TermF[200];
    char regGR[200], regEOF[200], prrFI[20];
    int tagEOF[3], tagGRA[3] = {1 , 1, 1}, sTags = 0, i = 0, nIgual = 0, k = 0, l, diff;

    FILE * index[3], *indexF;

    for (i = 0; i < 200; i++)
        regEOF[i] = 255;
    index[0] = NULL;
    index[1] = NULL;
    index[2] = NULL;

    //abrindos os arquivos
    index[0] = abreArquivo(nome1Arqu, "r");
    if (index[0] == NULL)
    {
        printf("Erro de Arquivo");
        exit(1);
    }
    index[1] = abreArquivo(nome2Arqu, "r");
    if (index[1] == NULL)
    {
        printf("Erro de Arquivo");
        exit(1);
    }
    index[2] = abreArquivo(nome3Arqu, "r");
    if (index[2] == NULL)
    {
        printf("Erro de Arquivo");
        exit(1);
    }
    indexF = abreArquivo(nomeF, "w+");
    if (index[2] == NULL)
    {
        printf("Erro de Arquivo");
        exit(1);
    }

    for (i = 0; i < 3; i++)
    {
        tagEOF[i] = pegaStringIM(reg[i], prr[i], index[i], &l);
        if (tagEOF[i] == 1)
        {
            strcpy(reg[i], regEOF);
            sTags++;
        }
    }
    
    //varrendo os index
    while (sTags < 3)
    {
        k = 0;
        for (i = 1; i < 3; i++)
        {
            diff = compara(reg[k], reg[i]);
            if (diff > 0)
                k = i;
        }
        
        if (k == 0)
        {
            strcpy(TermF, reg[k]);
            strcpy(prrFI, prr[0]);
            tagGRA[0] = 0;
        }
        
        nIgual = 0;
        strcpy(regGR, reg[k]);
        
        for (i = 0; i < 3; i++)
        {
            if (!strcmp(reg[i], regGR))
            {
                nIgual++;
                tagEOF[i] = pegaStringIM(reg[i], prr[i], index[i], &l);
                if (tagEOF[i] == 1)
                {
                    strcpy(reg[i], regEOF);
                    sTags++;
                }
            }
        }

        if (nIgual != 1)
            tagGRA[0] = 1;

        if (tagGRA[0] == 0)
        {
            fprintf(indexF, "%s;%s\n", TermF, prrFI);
            tagGRA[0] = 1;
        }
        
    }
    
    fclose(index[0]);
    fclose(index[1]);
    fclose(index[2]);
    fclose(indexF);
    
}

int trataFimArquiIM(int greg, int tag, char* reg1, char* prr1, FILE* index1, FILE* indexF, char* reg2, int p)
{
    int tag1 = tag, greg1 = greg;

    while (tag1 != 1)
    {
        if (!strcmp(reg1, reg2))
        {
            tag1 = pegaString(reg1, prr1, index1, &greg1);
        }
        else
        {
            if (greg1 == 1)
            {
                tag1 = pegaString(reg1, prr1, index1, &greg1);
                fprintf(indexF, "%s;%s;%d\n", reg1, prr1, p);
            }
            else
            {
                fprintf(indexF, "%s;%s;%d\n", reg1, prr1, p);
                tag1 = pegaString(reg1, prr1, index1, &greg1);
            }
        }
    }
    return tag1;
}

int pegaStringIM(char* registro, char* prr, FILE* index, int *valor)
{
    int i;
    if (feof(index))
        return 1;
    else
    {
        i = -1;
        do
        {
            i++;
            fscanf(index, "%c", &registro[i]);
            if (feof(index))
                return 1;
        }
        while (registro[i] != ';');
        registro[i] = '\0';

        i = -1;
        do
        {
            i++;
            fscanf(index, "%c", &prr[i]);
            if (feof(index))
                return 1;
        }
        while (prr[i] != '\n');
        prr[i] = '\0';
    }
    *valor = 0;
    return 0;
}

void geraArquIM(char *nome, char *nomTab)
{
    //variveis
    char reg[100], termo[100], lixo, exten[] = EXTENTAB;
    char nomeTab[100];
    int prr, arqu;
    FILE *table, *index, *tableC;

    strcpy(nomeTab, nomTab);
    removeExten(nomeTab);
    colocaExten(nomeTab, exten);
    //abrindos os arquivos
    tableC = abreArquivo(nomeTab, "r");
    if (tableC == NULL)
    {
        printf("Erro de Arquivo");
        exit(1);
    }

    //abrindos os arquivos gerados
    index = abreArquivo(nome, "r");
    if (table == NULL)
    {
        printf("Erro de Arquivo");
        exit(1);
    }
    removeExten(nome);
    colocaExten(nome, exten);
    table = abreArquivo(nome, "w+");
    if (table == NULL)
    {
        printf("Erro de Arquivo");
        exit(1);
    }

    //transformando o index em um novo arquivo
    while (!feof(index))
    {
        fscanf(index, "%[^;]", termo);
        if (feof(index))
            break;

        fscanf(index, "%c", &lixo);
        fscanf(index, "%d", &prr);
        fscanf(index, "%c", &lixo);

        fseek(tableC, prr, SEEK_SET);
        fscanf(tableC, "%[^\n]", reg);

        fprintf(table, "%s\n", reg);
    }

    //fechando os arquivos
    fclose(tableC);
    fclose(table);
    fclose(index);

}
